home *** CD-ROM | disk | FTP | other *** search
/ Complete Linux / Complete Linux.iso / docs / devel / lisp / kcl_tar.z / kcl_tar / c / fasl_pass2.c < prev    next >
Encoding:
C/C++ Source or Header  |  1987-06-04  |  4.3 KB  |  180 lines
  1. /*
  2. (C) Copyright Taiichi Yuasa and Masami Hagiya, 1984.  All rights reserved.
  3. */
  4.  
  5. /*
  6.     fasl_pass2.c
  7.     DG-SPECIFIC
  8.  
  9.     fasl loader pass2 routines
  10. */
  11.  
  12. #include "../h/fasl.h"
  13. #include "../h/fasl_global.h"
  14.  
  15. data_pass2()
  16. {
  17.     FAS_HDR_P    hdr_p;
  18.     FAS_DATA_P    data_p;
  19.     FAS_DICT_P    dict_p;
  20.  
  21.     int    not_over;    /* overwrite flag */
  22.     short    *block_end;    /* end of this block */
  23.     short    *rdata_p;    /* relocation data pointer */
  24.     short    *p_addr;    /* partition start addr */
  25.     short    *rdata_addr;    /* relocationed data addr */
  26.     short    *base_p;    /* base pointer */
  27.     short    *dword_p;    /* dictionaried data word pointer */
  28.     short    data_len;    /* copy of data_words */
  29.     short    base, repeat_count;
  30.     short    reloc;        /* relocation operation */
  31.     short    reloc_ex;    /* extended relocaton operation */
  32.  
  33.     /* initialize */
  34.     hdr_p = (FAS_HDR_P)fas_buffp;
  35.     if ((hdr_p->hdr_typ) && OVER_BIT)
  36.         not_over = FALSE;
  37.         else
  38.         not_over = TRUE;
  39.     block_end = (short *)fas_buffp + hdr_p->hdr_len;
  40.     data_p = (FAS_DATA_P)(fas_buffp + FAS_HEADER_BLEN);
  41.     if (datab_rev < 2)
  42.         rdata_p = (short *)(data_p + 1) - 2;
  43.         else
  44.         rdata_p = (short *)(data_p + 1);
  45.     data_len = data_p->data_words;
  46.     if (data_len == 0) return;
  47.  
  48.     if (datab_rev < 2)
  49.         repeat_count = 1;
  50.         else
  51.         repeat_count = data_p->data_repeat;
  52.     base = data_p->data_base;
  53.  
  54. /*
  55.     part_table_p = fasl_get_table(base);
  56.     p_addr = (short *)(part_table_p->part_addr);
  57. */
  58.     p_addr = fasl_get_addr(base);
  59.  
  60.     /* data relocation */
  61.     reloc = (data_p->data_reloc) & RELOC_OP;
  62.     reloc_ex = ((data_p->data_reloc) & RELOC_OP_EX) >> RELOC_OP_S;
  63.     if (reloc != EX_RELOC) unexpect_reloc(reloc);
  64.  
  65.     base_p = &(data_p->data_base);
  66.     dword_p = &(data_p->data_disp);
  67.     relocation(reloc_ex, base_p, dword_p);
  68.     rdata_addr = *((int *)dword_p);
  69.  
  70.     while(repeat_count-- > 0) {
  71. /*      if (not_over == TRUE)
  72.           fasl_set_map(rdata_addr - fas_rstart, data_len,
  73.                 rdata_p, rdata_addr);        */
  74.       /* block move data to alocated memory */
  75.       blockmove((char *)rdata_addr, (char *)rdata_p, data_len * 2);
  76.       dict_p = (FAS_DICT_P)(rdata_p + data_len);
  77.                 /* set to first dictionary */
  78.  
  79.       while (dict_p < block_end) {    /* loop for each dictionary */
  80.         reloc = (dict_p->dict_reloc) & RELOC_OP;
  81.         reloc_ex = ((dict_p->dict_reloc) & RELOC_OP_EX)
  82.                             >> RELOC_OP_S;
  83.  
  84. /*        if ((reloc != EX_RELOC) && (reloc != BIT_RELOC)) */
  85.         if (reloc != EX_RELOC)
  86.             unexpect_reloc(reloc);
  87.  
  88.         /* set base pointer */
  89.         base_p = &(dict_p->dict_base);
  90.           /* set dictionaried data word pointer */
  91.         if (datab_rev == 0)
  92.             dword_p = p_addr + dict_p->dict_data;
  93.             else        /* offset from partition */
  94.             dword_p = rdata_addr + dict_p->dict_data;
  95.                     /* offset from data */
  96.         /* relocate this data word */
  97.         relocation(reloc_ex, base_p, dword_p);
  98.         /* for next dictionary */
  99.         dict_p = dict_p + 1;
  100.       }    /* end of while for each dictionary */
  101.  
  102.       /* advance rdata_addr to relocate once more */
  103.       rdata_addr += data_len;
  104.     }    /* end of while for repeat count */
  105. }
  106.  
  107. ent_pass2()
  108. {
  109.     FAS_HDR_P    hdr_p;
  110.     FAS_ENT_P    ent_p;
  111.     FAS_ENTD_P    entd_p;
  112.  
  113.     short    name_len, base, reloc, reloc_ex;
  114.     short    *base_p, *dword_p;
  115.     long    disp;
  116.     char    *name_ptr;
  117.     char    namebuff[MAX_SYMBOL + 1];
  118.     int    i, repeat;
  119.  
  120.     if (fas_routine_addr != 0) return;
  121.  
  122.     hdr_p = (FAS_HDR_P)fas_buffp;
  123.     ent_p = (FAS_ENT_P)(hdr_p + 1);
  124.     entd_p = (FAS_ENTD_P)(ent_p + 1);
  125.  
  126.     repeat = ent_p->ent_count;
  127.  
  128.     while (repeat-- > 0) {
  129.        name_len = (entd_p->entd_len) & L_MASK;
  130.        if (name_len < 4) goto NEXT;
  131.        name_ptr = (char *)fas_buffp + (entd_p->entd_ptr);
  132.        for (i=0; i < 4; i++)    /* compare first 4 bytes */
  133.         namebuff[i] = *(name_ptr + i);
  134.        namebuff[i] = '\0';
  135.  
  136.        if (strcmp(fas_routine_name, namebuff) == 0) goto FOUND_SYM;
  137.                 /* init routine name ? */
  138.  
  139. NEXT:
  140.        entd_p += 1;    /* advance for next */
  141.        continue;
  142.  
  143. FOUND_SYM:
  144.        /* We found the init routine's symbol. Relocate it. */
  145.  
  146.        reloc = entd_p->entd_reloc & RELOC_OP;
  147.        reloc_ex = (entd_p->entd_reloc & RELOC_OP_EX) >> RELOC_OP_S;
  148.  
  149.        if (reloc != EX_RELOC) unexpect_reloc(reloc);
  150.  
  151.        base_p = &(entd_p->entd_base);
  152.        dword_p = &(entd_p->entd_disp);
  153.        relocation(reloc_ex, base_p, dword_p);
  154.  
  155.        /* save init routine address */
  156.        fas_routine_addr = *((int *)dword_p);
  157.        break;
  158.        }    /* end of while */
  159. }
  160.  
  161. fasl_set_map(sb, len, sp, dp)
  162. int sb, len;
  163. short *sp, *dp;
  164. {
  165.     int    i, mask;
  166.  
  167. /*
  168.     while(len-- > 0) {
  169.         i = sb / 32;
  170.         mask = 1 << (31 - sb % 32);
  171.         if ((fas_map[i] & mask) &&
  172.             (*(dp + sb) != *(sp + sb)))
  173.             FEerror("Overwrite error", 0);
  174.         fas_map[i] |= mask;
  175.         sb++;
  176.     }
  177. */
  178. }
  179.  
  180.